﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

using ControlsLib;
using GestionePolveri2.DAL;
using GestionePolveriLib.Facades;
using GestionePolveriLib.BL;
using System.Security.Permissions;
using Be.Timvw.Framework.ComponentModel;
using System.ComponentModel.DataAnnotations;
using GestionePolveriLib.BL.Metadata;
using FrameworkLib.Utilities.Export;
using GestionePolveri2.Reports;
using ControlsLib.Toolbars;
using FrameworkLib.Utilities;
using GestionePolveriLib.BL.Filters;
using System.Threading;

namespace GestionePolveri2
{
    [MetadataType(typeof(Movimento3Metadata))]
    [ToolbarAttribute(true)]
    public partial class ScaricoMovimenti : ScaricoMovimentiBase
    {
        private MovimentoScaricoFilterBag m_filter = null;
        private ElencoPartite m_elencoPartite = null;

        private Turno m_turno = null;
        private Impianto m_impianto = null;
        private Impianto m_impiantoFitt = null;
        private bool m_almostOneIsCloned = false;

        public DateTime DataMovimento
        {
            get { return this.dataMovimentoFilter.Value; }
        }

        public Turno Turno
        {
            get 
            {
                Turno item = ((MainFormToolbar)this.GetToolbar()).GetSelectedItem<Turno>("cmbTurni");

                if (item != null)
                {
                    if (item.Id == -1)
                    {
                        item = null;
                    }
                }
                return item; 
            }
        }

        public Impianto Impianto
        {
            get 
            {
                Impianto m_impianto = null;

                MainFormToolbar mt = (MainFormToolbar)this.GetToolbar();

                m_impianto = ((MainFormToolbar)this.GetToolbar()).GetSelectedItem<Impianto>("cmbImp");
                if (m_impianto != null)
                {
                    if (m_impianto.ID == -1)
                    {
                        m_impianto = ((MainFormToolbar)this.GetToolbar()).GetSelectedItem<Impianto>("cmbImpFitt");
                        if (m_impianto.ID == -1)
                        {
                            m_impianto = null;
                        }
                    }
                }

                return m_impianto;
            }
        }

        public ScaricoMovimenti()
        {
            InitializeComponent();
        }

        public override void InitializeForm()
        {
            base.InitializeForm();

            if (!this.DesignMode)
            {
                this.SuspendLayout();

                m_filter = new MovimentoScaricoFilterBag();
                m_filter.UseDates = true;
                //m_filter.Operatore = (this.Principal.IsInRole("Verniciatura") ? this.Principal.Identity.Name : null);
                m_filter.PeriodFrom = this.dataMovimentoFilter.Value;
                m_filter.PeriodTo = this.dataMovimentoFilter.Value;
                m_filter.CausaleScarico = "S";
                //m_filter.Impianto = this.Impianto.Nome;
                //m_filter.Turno = this.Turno.Descrizione;

                //MainFormToolbar mt = (MainFormToolbar)this.GetToolbar();
                //mt.EventRaised += new EventHandler<CustomEventArgs<object>>(mt_EventRaised);
                
                //GeneralToolbar ts = (GeneralToolbar)this.ParentForm.Controls["generalToolbar1"];
                //ts.Visible = true;
                this.FormClosing += new FormClosingEventHandler(ScaricoMovimenti_FormClosing);

                this.AddCustomButton("btnRicarica", "Ricarica Dati");
                if ((!this.Principal.IsInRole("Direzione")) && (!this.Principal.IsInRole("Produzione")))
                {
                    this.AddCustomButton("btnNuovo", "Nuovo");
                    this.AddCustomButton("btnClone", "Clona Movimento");
                }
                this.AddCustomButton("btnStampa", "Stampa");

                this.EnableSorting = true;

                this.CanModify = true;
                this.FormClosing += new FormClosingEventHandler(ScaricoMovimenti_FormClosing);
                this.ButtonClicked += new EventHandler<CustomEventArgs<Movimento>>(ScaricoMovimenti_ButtonClicked);
                //this.ItemSelected += new EventHandler<CustomEventArgs<Movimento>>(ScaricoMovimenti_ItemSelected);
                this.CustomButtonClicked += new EventHandler<CustomEventArgs<Movimento>>(ScaricoMovimenti_CustomButtonClicked);

                this.dataGridView1.RowPostPaint += new DataGridViewRowPostPaintEventHandler(dataGridView1_RowPostPaint);           

                this.PanelMessage = "SCARICO";

                this.ShowOnlyCustomButton = true;

                this.dataMovimentoFilter.Value = System.DateTime.Now;
                this.dataMovimentoFilter.ValueChanged += new EventHandler(dynDataMovimentoFilter_ValueChanged);

                this.splitContainer1.Panel2Collapsed = true;
                this.splitContainer1.Panel2.Hide();

                this.ResumeLayout();

                if (this.ParentForm == null)
                {
                    MessageBox.Show(string.Format("{0}: Parentform null", this.Name));
                }

                if (this.Principal.IsInRole("Verniciatura"))
                {
                    VerniciatoreSceltaTurnoDialog vstd = new VerniciatoreSceltaTurnoDialog();
                    DialogResult result = vstd.ShowDialog();
                    switch (result)
                    {
                        case DialogResult.Abort:
                            this.Dispose();
                            break;
                        case DialogResult.Cancel:
                            break;
                        case DialogResult.OK:
                            m_turno = vstd.Turno;
                            m_impianto = vstd.Impianto;
                            m_impiantoFitt = vstd.ImpiantoFitt;
                            break;
                    }

                    //if (vstd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                    //{
                    //    m_turno = vstd.Turno;
                    //    m_impianto = vstd.Impianto;
                    //    m_impiantoFitt = vstd.ImpiantoFitt;
                    //}
                }
            }
        }

        protected override void ToolBarInitialization(MainFormToolbar toolbar)
        {
            base.ToolBarInitialization(toolbar);

            MainToolBarDecorator mc = new MainToolBarDecorator(toolbar);
            mc.LoadComplete += new EventHandler(mc_LoadComplete);
            mc.AddComboImpiantiFittizi();
            mc.AddComboImpianti();
            mc.AddComboTurni();

            if (this.Principal.IsInRole("Verniciatura"))
            {
                ((MainFormToolbar)this.GetToolbar()).Enabled("cmbTurni", false);
                ((MainFormToolbar)this.GetToolbar()).Enabled("cmbImp", false);
                ((MainFormToolbar)this.GetToolbar()).Enabled("cmbImpFitt", false);

                if (m_elencoPartite == null)
                {
                    if ((m_turno != null) && ((m_impianto != null) || (m_impiantoFitt != null)))
                    {
                        m_elencoPartite = new ElencoPartite();
                        m_elencoPartite.InitializeForm(m_turno.Descrizione, (m_impianto != null ? m_impianto.Nome : m_impiantoFitt.Nome), this.dataMovimentoFilter.Value);
                        m_elencoPartite.ShowOnMonitor(1);
                    }
                }
            }
        }

        void mc_LoadComplete(object sender, EventArgs e)
        {
            if (this.Principal.IsInRole("Verniciatura"))
            {
                if (m_turno != null)
                {
                    ((MainFormToolbar)this.GetToolbar()).SetSelectedItem<Turno>("cmbTurni", m_turno.Descrizione);
                }

                if (m_impianto != null)
                {
                    ((MainFormToolbar)this.GetToolbar()).SetSelectedItem<Impianto>("cmbImp", m_impianto.Nome);
                }

                if (m_impiantoFitt != null)
                {
                    ((MainFormToolbar)this.GetToolbar()).SetSelectedItem<Impianto>("cmbImpFitt", m_impiantoFitt.Nome);
                }
            }
        }

        protected override void OnToolBarEventRaised(object sender, CustomEventArgs<object> e)
        {
            base.OnToolBarEventRaised(sender, e);

            if (e.Action == Actions.FromCombo)
            {
                ToolStripItem item = (ToolStripItem)e.Item;

                if (item.Name == "cmbTurni")
                {
                    m_filter.Turno = (item.Text.ToLower().Contains("seleziona") ? string.Empty : this.Turno.Descrizione);
                }

                if (item.Name == "cmbImp")
                {
                    MainFormToolbar mt = (MainFormToolbar)this.GetToolbar();
                    mt.GetToolbarItem("cmbImpFitt").Enabled = (item.Text.ToLower().Contains("seleziona") ? true : false);

                    m_filter.Impianto = (item.Text.ToLower().Contains("seleziona") ? string.Empty : this.Impianto.Nome); 
                }

                if (item.Name == "cmbImpFitt")
                {
                    MainFormToolbar mt = (MainFormToolbar)this.GetToolbar();
                    mt.GetToolbarItem("cmbImp").Enabled = (item.Text.ToLower().Contains("seleziona") ? true : false);

                    m_filter.Impianto = (item.Text.ToLower().Contains("seleziona") ? string.Empty : this.Impianto.Nome);
                }

                LoadData();
            }
        }

        void ScaricoMovimenti_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (this.Principal.IsInRole("Verniciatura"))
            {
                System.Security.Principal.IPrincipal m_operatore = System.Threading.Thread.CurrentPrincipal;
                OperatoriFacade opf = new OperatoriFacade();
                Operatore m_op = opf.GetOperatore(m_operatore.Identity.Name);

                if ((this.Turno != null) && (this.Impianto != null))
                {
                    ControlloAccessoVerniciatoriFacade cavf = new ControlloAccessoVerniciatoriFacade();
                    cavf.Unblock(this.Turno.Id, this.Impianto.ID, m_op.ID);
                }
            }

            if (m_elencoPartite != null)
            {
                m_elencoPartite.Close();
            }
        }

        void dataGridView1_RowPostPaint(object sender, DataGridViewRowPostPaintEventArgs e)
        {
            DataGridViewRow row = this.dataGridView1.Rows[e.RowIndex];

            if (((Movimento)row.DataBoundItem).IsCloned)
            {
                //Convert the image to icon, in order to load it in the row header column
                Bitmap myBitmap = new Bitmap(GestionePolveri2.Properties.Resources.navigate_right2);
                Icon myIcon = Icon.FromHandle(myBitmap.GetHicon());

                Graphics graphics = e.Graphics;

                //Set Image dimension - User's choice
                int iconHeight = 14;
                int iconWidth = 14;

                //Set x/y position - As the center of the RowHeaderCell
                //int xPosition = e.RowBounds.X + (dataGridView1.RowHeadersWidth / 2);
                int xPosition = e.RowBounds.X + 5;
                int yPosition = e.RowBounds.Y + ((dataGridView1.Rows[e.RowIndex].Height - iconHeight) / 2);

                Rectangle rectangle = new Rectangle(xPosition, yPosition, iconWidth, iconHeight);
                graphics.DrawIcon(myIcon, rectangle);

                m_almostOneIsCloned = true;
            }

            if (((Movimento)row.DataBoundItem).LottoNCInfo != null)
            {
                LottoNCInfo m_lottoNCInfo = ((Movimento)row.DataBoundItem).LottoNCInfo;

                if (((m_lottoNCInfo.IsLottoBloccato.HasValue) && (m_lottoNCInfo.IsLottoBloccato.Value)) ||
                    ((m_lottoNCInfo.IsLottoNC.HasValue) && (m_lottoNCInfo.IsLottoNC.Value)))
                {
                    Bitmap myBitmap = new Bitmap((m_lottoNCInfo.IsLottoBloccato.Value ? GestionePolveri2.Properties.Resources.lgNC_B :
                                                                                  GestionePolveri2.Properties.Resources.lgNC));
                    Icon myIcon = Icon.FromHandle(myBitmap.GetHicon());

                    Graphics graphics = e.Graphics;

                    //Set Image dimension - User's choice
                    int iconHeight = 16;
                    int iconWidth = 31;

                    //Set x/y position - As the center of the RowHeaderCell
                    //int xPosition = e.RowBounds.X + 5;
                    int xPosition = e.RowBounds.X + (((Movimento)row.DataBoundItem).IsCloned ? 20 : 5);
                    int yPosition = e.RowBounds.Y + ((dataGridView1.Rows[e.RowIndex].Height - iconHeight) / 2);

                    Rectangle rectangle = new Rectangle(xPosition, yPosition, iconWidth, iconHeight);
                    graphics.DrawIcon(myIcon, rectangle);

                    if (m_almostOneIsCloned)
                    {
                        dataGridView1.RowHeadersWidth = 55;
                    }
                    else
                    {
                        dataGridView1.RowHeadersWidth = 43;
                    }
                }
            }
        }

        private void NascondiColonne()
        {
            if (this.dataGridView1 != null)
            {
                if(this.dataGridView1.Columns["NumDDT"] != null)
                  this.dataGridView1.Columns["NumDDT"].Visible = false;

                if (this.dataGridView1.Columns["DataDDT"] != null)
                  this.dataGridView1.Columns["DataDDT"].Visible = false;
            }
            //if ((!this.Principal.IsInRole("Amministrazione")) && (!this.Principal.IsInRole("Direzione")))
            //{
            //    this.dataGridView1.Columns["Operatore"].Visible = false;
            //}
        }

        void dynDataMovimentoFilter_ValueChanged(object sender, EventArgs e)
        {
            this.dataGridView1.DataSource = null;

            m_filter.PeriodFrom = this.dataMovimentoFilter.Value;
            m_filter.PeriodTo = this.dataMovimentoFilter.Value;

            LoadData();

            if (m_elencoPartite != null)
            {
                m_elencoPartite.InitializeForm(this.Turno.Descrizione, this.Impianto.Nome, this.dataMovimentoFilter.Value);
            }
        }

        private void LoadData()
        {
            if (this.Principal.IsInRole("Verniciatura"))
            {
                if ((m_filter.Impianto == null) || (m_filter.Turno == null))
                {
                    return;
                }

                if ((m_filter.Impianto == null) && (m_filter.Turno == null))
                {
                    MessageBox.Show("Selezionare Turno ed Impianto.", "Gestione Polveri", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    return;
                }
            }

            this.dataGridView1.DataSource = null;

            if (m_filter == null) return;

            m_almostOneIsCloned = false;

            TurniFacade tf = new TurniFacade();
            Turno m_turnoDefault = tf.GetTurnoND();


            MovimentiFacade pf = new MovimentiFacade();
            pf.RunAsync<List<Movimento>>(() => pf.GetMovimentiWithPartite("S", this.dataMovimentoFilter.Value, m_filter.Impianto, m_turnoDefault), (result) =>
            //pf.RunAsync<List<Movimento>>(() => pf.GetMovimentiWithPartite(m_filter), (result) =>
            {
                if (result != null)
                {
                    List<Movimento> ppp = (List<Movimento>)result;

                    List<Movimento> ppp1 = new List<Movimento>();
 
                    // schifezza necessaria in quanto la query linq con filtro dinamico non vuole saperne di funzionare
                    if ((!string.IsNullOrWhiteSpace(m_filter.Impianto)) && (!string.IsNullOrWhiteSpace(m_filter.Turno)))
                    {
                        ppp = ppp.Where(m => m.Turno.Descrizione.Equals(m_filter.Turno, StringComparison.InvariantCultureIgnoreCase))
                                 .Where(m => m.Impianto.Equals(m_filter.Impianto, StringComparison.InvariantCultureIgnoreCase))
                                 .ToList();

                        //ppp = ppp.Where(m => m.Turno.Descrizione.Equals(m_filter.Turno, StringComparison.InvariantCultureIgnoreCase))
                        //         .Where(m => m.Impianto.Equals(m_filter.Impianto, StringComparison.InvariantCultureIgnoreCase))
                        //         .ToList();
                    }
                    else
                    {
                        if (!string.IsNullOrWhiteSpace(m_filter.Turno))
                        {
                            ppp = ppp.Where(m => m.Turno.Descrizione.Equals(m_filter.Turno, StringComparison.InvariantCultureIgnoreCase)).ToList();
                        }
                        else
                        {
                            if (!string.IsNullOrWhiteSpace(m_filter.Impianto))
                            {
                                ppp = ppp.Where(m => m.Impianto.Equals(m_filter.Impianto, StringComparison.InvariantCultureIgnoreCase)).ToList();
                            }
                        }
                    }
                    // schifezza necessaria in quanto la query linq con filtro dinamico non vuole saperne di funzionare

                    this.Datasource = ppp;

                    //SetGridItemSelected(0);

                    NascondiColonne();
                }
                else
                {
                    //base.ClearControls(this.Controls);
                    //base.ForceCurrentAction(Actions.New);
                }
            });

        }

        //protected override void OnClosing(CancelEventArgs e)
        //{
        //    base.OnClosing(e);

        //    MainToolbar mt = (MainToolbar)this.GetToolbar();
        //    mt.Visible = false;
        //    mt.EventRaised -= new EventHandler<CustomEventArgs<object>>(mt_EventRaised);
        //}

        private void InizializzaCampi()
        {

        }

        public T DeepClone<T>(T obj)
        {
            T objResult;
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
            {
                System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                bf.Serialize(ms, obj);
                ms.Position = 0;
                objResult = (T)bf.Deserialize(ms);
            }
            return objResult;
        }

        void ScaricoMovimenti_CustomButtonClicked(object sender, CustomEventArgs<Movimento> e)
        {
            if (e.ButtonName.Equals("btnRicarica", StringComparison.InvariantCultureIgnoreCase))
            {
                LoadData();
            }

            if (e.ButtonName.Equals("btnNuovo", StringComparison.InvariantCultureIgnoreCase))
            {
                if ((this.Turno != null) && (this.Turno.Id == -1))
                {
                    MessageBox.Show("Selezionare un Turno !", "Gestione Polveri", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                    return;
                }

                if ((this.Impianto != null) && (this.Impianto.ID == -1))
                {
                    MessageBox.Show("Selezionare un Impianto !", "Gestione Polveri", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                    return;
                }

                GestionePolveri2.Editors.ScaricoEditor ce = new Editors.ScaricoEditor();
                ce.EditorStatus = Editors.EditorStatus.Insert;
                ce.Principal = (OperatorePrincipal)this.Principal;
                ce.DataMovimento = this.dataMovimentoFilter.Value; 
                //ce.DataRegistrazione = this.dataMovimentoFilter.Value;
                ce.Funtion = "";
                ce.Turno = this.Turno;
                ce.Impianto = this.Impianto;
                ce.GeneratePOS();

                ce.Initialize();

                if (this.Principal.IsInRole("Amministrazione"))
                {
                    ce.TurnoEnabled = true;
                    ce.ImpiantoEnabled = true;
                }

                if (ce.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    LoadData();

                    if (m_elencoPartite != null)
                    {
                        m_elencoPartite.InitializeForm(this.Turno.Descrizione, this.Impianto.Nome, this.dataMovimentoFilter.Value);
                    }
                }
            }

            if (e.ButtonName.Equals("btnClone", StringComparison.InvariantCultureIgnoreCase))
            {
                if (this.dataGridView1.CurrentRow != null)
                {
                    if (MessageBox.Show("Replica Scarico.\nLa replica viene eseguita a partire dal movimento di scarico selezionato.\nVuoi Procedere ?", "Gestione Polveri", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == System.Windows.Forms.DialogResult.Yes)
                    {
                        Movimento movimentoPadre = (Movimento)this.dataGridView1.CurrentRow.DataBoundItem;
                        if (movimentoPadre != null)
                        {
                            MovimentoPartitaToExport mpte = new MovimentoPartitaToExport(movimentoPadre);
                            mpte.IsCloned = true;
                            mpte.Quantita = 0;
                            mpte.NumScatole = 0;

                            MovimentiFacade mf = new MovimentiFacade();
                            //Movimento m = mf.GetMovimento(mpte.IDMovimento);
                            
                            ImpiantoFacade impf = new ImpiantoFacade();
                            Impianto imp = impf.GetImpianto(mpte.IDImpianto.GetValueOrDefault());

                            OperatoriFacade opf = new OperatoriFacade();
                            Operatore op = opf.GetOperatore(mpte.Operatore);

                            POS m_pos = POS.GetCurrentPOS(mpte.Turno, op, imp, mpte.DataMovimento);

                            PartiteFacade pf = new PartiteFacade();
                            PartitaInfo pInfoPadre = pf.GetByMovimento(mpte.IDMovimento);

                            PartitaInfo pInfo = null;
                            if (pInfoPadre != null)
                            {    
                                pInfo = new PartitaInfo();
                                pInfo.Movimento = mpte;
                                pInfo.POS = m_pos;
                                pInfo.ColoreVerniciato = pInfoPadre.ColoreVerniciato;
                                pInfo.QuantitaVerniciata = null;
                                pInfo.LatoA = null;
                                pInfo.LatoB = null;
                                pInfo.FlagConforme = true;
                            }

                            mpte.POS = m_pos.POSValue;
                            //mpte.Note += string.Format(" *** REPLICA DEL MOVIMENTO/PARTITA {0} / {1} ***", movimentoPadre.IDMovimento, movimentoPadre.POS);

                            mpte.Note += string.Format(" *** REPLICA DEL MOVIMENTO {0} {1} ***", movimentoPadre.IDMovimento,
                                                                   (pInfo == null ? "" : string.Format("/ POS {0}", movimentoPadre.POS)));

                            POSTableFacade ptf = new POSTableFacade();

                            mf.Transact(()=>{
                                if (mf.AddMovimento(mpte))
                                {
                                    if (pInfo != null)
                                    {
                                        pInfo.Movimento = mpte;
                                        pf.Add(pInfo);
                                    }

                                    ptf.UpdatePOS(mpte.Turno, op, imp, m_pos, mpte.DataMovimento);
                                }
                            });

                            MessageBox.Show("Replica Eseguita !", "Gestione Polveri", MessageBoxButtons.OK, MessageBoxIcon.Information);
                            
                            LoadData();

                            FormCollection fColl = Application.OpenForms;

                            foreach (Form f in fColl)
                            {
                                if (f.Name == "ElencoPartite")
                                {
                                    //((IForm)f).InitializeForm();
                                    ((ElencoPartite)f).InitializeForm(this.Turno.Descrizione, this.Impianto.Nome, this.dataMovimentoFilter.Value);
                                }
                            }
                        }
                        else
                        {
                            MessageBox.Show("Replica Fallita. Selezionare un movimento di scarico !", "Gestione Polveri", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                        }
                    }
                }
                else
                {
                    MessageBox.Show("Selezionare un movimento di scarico !", "Gestione Polveri", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
            }

            if (e.ButtonName.Equals("btnStampa", StringComparison.InvariantCultureIgnoreCase))
            {
                Button btn = this.ButtonBar.GetCustomButton("btnStampa");
                this.contextMenuStrip1.Show(btn, new Point(0, 0), ToolStripDropDownDirection.AboveRight);
            }
        }

        void ScaricoMovimenti_ButtonClicked(object sender, CustomEventArgs<Movimento> e)
        {
            switch (e.Action)
            {
                case Actions.Cancel:
                    {
                        base.ClearControls(this.Controls);

                        SetGridItemSelected(0);
                    }
                    break;
                case Actions.New:
                    {
                        base.ClearControls(this.Controls);
                    }
                    break;
                case Actions.Add:
                    {
                    }
                    break;
                case Actions.Modify:
                    {
                    }
                    break;
                case Actions.Delete:
                    {
                        if (MessageBox.Show("Stai cancellando uno scarico. Vuoi procedere ?", "Scarico Movimenti", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == System.Windows.Forms.DialogResult.Yes)
                        {
                        }
                    }
                    break;
                default:
                    break;
            }
        }

        void ScaricoMovimenti_ItemSelected(object sender, CustomEventArgs<Movimento> e)
        {
            base.Current = e.Item;            
        }

        protected override void OnGridCellFormatting(object sender, DataGridViewCellFormattingEventArgs e)
        {
            base.OnGridCellFormatting(sender, e);

            if (this.dataGridView1.Columns.Contains("GiacenzaFinale"))
            {
                int index = this.dataGridView1.Columns["GiacenzaFinale"].DisplayIndex; // se conosci il nome

                // ANTONELLA:
                // cosi puoi colorare una cella sulla base di un valore specifico per una proprietà dell'oggetto
                // bindato alla riga della griglia.
                Movimento m = (Movimento)this.dataGridView1.Rows[e.RowIndex].DataBoundItem;

                if (e.ColumnIndex == index)  // se conosci la posizione della colonna
                {
                    if (m != null)
                    {
                        if (m.GiacenzaInsufficienteFlag || m.SottoScortaFlag)
                        {
                            e.CellStyle.ForeColor = Color.Red;
                        }
                    }
                }
            }
        }

        protected override void OnRowHeaderMouseDoubleClick(object sender, DataGridViewCellMouseEventArgs e)
        {
            if ((this.Principal.IsInRole("Direzione")) || (this.Principal.IsInRole("Produzione")))
            {
                MessageBoxA("Funzione non abilitata !");
                return;
            }

            base.OnRowHeaderMouseDoubleClick(sender, e);

            Turno m_turno = (this.Current.Turno != null ? this.Current.Turno : this.Turno);

            Impianto imp = null;
            if (this.Current.IDImpianto.HasValue)
            {
                ImpiantoFacade impf = new ImpiantoFacade();
                imp = impf.GetImpianto(this.Current.IDImpianto.Value);

                // aggiornare la combo della toolbar ?
            }
            else
            {
                imp = this.Impianto;
            }

            GestionePolveri2.Editors.ScaricoEditor ce = new Editors.ScaricoEditor();
            ce.Movimento = this.Current;
            ce.EditorStatus = Editors.EditorStatus.Modifiy;
            ce.Principal = (OperatorePrincipal)this.Principal;
            //ce.DataRegistrazione = this.dataMovimentoFilter.Value;
            ce.Funtion = "";
            ce.Turno = m_turno;
            ce.Impianto = imp;

            ce.Initialize();

            if (this.Principal.IsInRole("Amministrazione"))
            {
                ce.TurnoEnabled = true;
                ce.ImpiantoEnabled = true;
            }

            if (ce.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                LoadData();

                if (m_elencoPartite != null)
                {
                    m_elencoPartite.InitializeForm(this.Turno.Descrizione, this.Impianto.Nome, this.dataMovimentoFilter.Value);
                }
            }
        }

        private void esportaInExcelToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (this.dataGridView1.DataSource == null)
            {
                MessageBox.Show("Nessun dato pronto per la stampa !", "Gestione Polveri", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            SortableBindingList<Movimento> result = (SortableBindingList<Movimento>)this.dataGridView1.DataSource;

            SortableBindingList<MovimentoPartitaToExport> newList = new SortableBindingList<MovimentoPartitaToExport>();
            foreach (Movimento m in result) { newList.Add(new MovimentoPartitaToExport(m)); }

            if (newList != null)
            {
                SaveFileDialog sfd = new SaveFileDialog();
                sfd.Filter = "Excel Files (.xls)|*.xls|All Files (*.*)|*.*";
                sfd.FilterIndex = 1;
                if (sfd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    string errorMessage = string.Empty;
                    if (((SortableBindingList<MovimentoPartitaToExport>)newList).ToExcel(sfd.FileName, out errorMessage))
                    {
                        MessageBox.Show("Esportazione in Excel effettuata!", "Gestione Polveri", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    }
                    else
                    {
                        MessageBox.Show(string.Format("ATTENZIONE: Si è verificato un errore: {0}", errorMessage), "Gestione Polveri", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                }
            }
            else
            {
                MessageBox.Show("Nessun dato da inviare in stampa.", "Gestione Polveri", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }

        private void stampaReportConsumoPolveriToolStripMenuItem_Click(object sender, EventArgs e)
        {
            //MovimentiFacade pf = new MovimentiFacade();
            //List<Movimento> result = pf.GetMovimentiWithPartite("S", this.dataRegistrazione.Value);

            if (this.dataGridView1.DataSource == null)
            {
                MessageBox.Show("Nessun dato pronto per la stampa !", "Gestione Polveri", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            List<Movimento> result = new List<Movimento>();
            foreach (Movimento m in ((IEnumerable<Movimento>)this.dataGridView1.DataSource))
            {
                result.Add(m);
            }
                
            result = result.OrderBy(x => x.DataMovimento).OrderBy(x => x.POS).ToList();


            ReportViewerDialog2 rvd = new ReportViewerDialog2();
            rvd.Datasource = result;
            rvd.Report = "ReportConsumoPolveri";
            rvd.ShowReport();
        }
    }


    public class ScaricoMovimentiBase : AnagraficaManager<Movimento> { }
    //public class ScaricoMovimentiBase2 : AnagraficaManagerObjectListView<Movimento> { }
}
